// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
 *******************************************************************************
 *   Copyright (C) 2001-2012, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *******************************************************************************
 */

package com.ibm.icu.text;

import com.ibm.icu.impl.UBiDiProps;
import com.ibm.icu.lang.UCharacterDirection;

/**
 * Shape Arabic text on a character basis.
 *
 * <p>ArabicShaping performs basic operations for "shaping" Arabic text. It is most useful for use
 * with legacy data formats and legacy display technology (simple terminals). All operations are
 * performed on Unicode characters.
 *
 * <p>Text-based shaping means that some character code points in the text are replaced by others
 * depending on the context. It transforms one kind of text into another. In comparison, modern
 * displays for Arabic text select appropriate, context-dependent font glyphs for each text element,
 * which means that they transform text into a glyph vector.
 *
 * <p>Text transformations are necessary when modern display technology is not available or when
 * text needs to be transformed to or from legacy formats that use "shaped" characters. Since the
 * Arabic script is cursive, connecting adjacent letters to each other, computers select images for
 * each letter based on the surrounding letters. This usually results in four images per Arabic
 * letter: initial, middle, final, and isolated forms. In Unicode, on the other hand, letters are
 * normally stored abstract, and a display system is expected to select the necessary glyphs. (This
 * makes searching and other text processing easier because the same letter has only one code.) It
 * is possible to mimic this with text transformations because there are characters in Unicode that
 * are rendered as letters with a specific shape (or cursive connectivity). They were included for
 * interoperability with legacy systems and codepages, and for unsophisticated display systems.
 *
 * <p>A second kind of text transformations is supported for Arabic digits: For compatibility with
 * legacy codepages that only include European digits, it is possible to replace one set of digits
 * by another, changing the character code points. These operations can be performed for either
 * Arabic-Indic Digits (U+0660...U+0669) or Eastern (Extended) Arabic-Indic digits
 * (U+06f0...U+06f9).
 *
 * <p>Some replacements may result in more or fewer characters (code points). By default, this means
 * that the destination buffer may receive text with a length different from the source length. Some
 * legacy systems rely on the length of the text to be constant. They expect extra spaces to be
 * added or consumed either next to the affected character or at the end of the text.
 *
 * @stable ICU 2.0
 */
public final class ArabicShaping {
    private final int options;
    private boolean isLogical; // convenience
    private boolean spacesRelativeToTextBeginEnd;
    private char tailChar;

    /**
     * Convert a range of text in the source array, putting the result into a range of text in the
     * destination array, and return the number of characters written.
     *
     * @param source An array containing the input text
     * @param sourceStart The start of the range of text to convert
     * @param sourceLength The length of the range of text to convert
     * @param dest The destination array that will receive the result. It may be <code>NULL</code>
     *     only if <code>destSize</code> is 0.
     * @param destStart The start of the range of the destination buffer to use.
     * @param destSize The size (capacity) of the destination buffer. If <code>destSize</code> is 0,
     *     then no output is produced, but the necessary buffer size is returned ("preflighting").
     *     This does not validate the text against the options, for example, if letters are being
     *     unshaped, and spaces are being consumed following lamalef, this will not detect a lamalef
     *     without a corresponding space. An error will be thrown when the actual conversion is
     *     attempted.
     * @return The number of chars written to the destination buffer. If an error occurs, then no
     *     output was written, or it may be incomplete.
     * @throws ArabicShapingException if the text cannot be converted according to the options.
     * @stable ICU 2.0
     */
    public int shape(
            char[] source,
            int sourceStart,
            int sourceLength,
            char[] dest,
            int destStart,
            int destSize)
            throws ArabicShapingException {
        if (source == null) {
            throw new IllegalArgumentException("source can not be null");
        }
        if (sourceStart < 0 || sourceLength < 0 || sourceStart + sourceLength > source.length) {
            throw new IllegalArgumentException(
                    "bad source start ("
                            + sourceStart
                            + ") or length ("
                            + sourceLength
                            + ") for buffer of length "
                            + source.length);
        }
        if (dest == null && destSize != 0) {
            throw new IllegalArgumentException("null dest requires destSize == 0");
        }
        if ((destSize != 0)
                && (destStart < 0 || destSize < 0 || destStart + destSize > dest.length)) {
            throw new IllegalArgumentException(
                    "bad dest start ("
                            + destStart
                            + ") or size ("
                            + destSize
                            + ") for buffer of length "
                            + dest.length);
        }
        /* Validate input options */
        if (((options & TASHKEEL_MASK) != 0)
                && !(((options & TASHKEEL_MASK) == TASHKEEL_BEGIN)
                        || ((options & TASHKEEL_MASK) == TASHKEEL_END)
                        || ((options & TASHKEEL_MASK) == TASHKEEL_RESIZE)
                        || ((options & TASHKEEL_MASK) == TASHKEEL_REPLACE_BY_TATWEEL))) {
            throw new IllegalArgumentException("Wrong Tashkeel argument");
        }

        /// CLOVER:OFF
        // According to Steven Loomis, the code is unreachable when you OR all the constants within
        // the if statements
        if (((options & LAMALEF_MASK) != 0)
                && !(((options & LAMALEF_MASK) == LAMALEF_BEGIN)
                        || ((options & LAMALEF_MASK) == LAMALEF_END)
                        || ((options & LAMALEF_MASK) == LAMALEF_RESIZE)
                        || ((options & LAMALEF_MASK) == LAMALEF_AUTO)
                        || ((options & LAMALEF_MASK) == LAMALEF_NEAR))) {
            throw new IllegalArgumentException("Wrong Lam Alef argument");
        }
        /// CLOVER:ON

        /* Validate Tashkeel (Tashkeel replacement options should be enabled in shaping mode only)*/
        if (((options & TASHKEEL_MASK) != 0) && (options & LETTERS_MASK) == LETTERS_UNSHAPE) {
            throw new IllegalArgumentException(
                    "Tashkeel replacement should not be enabled in deshaping mode ");
        }
        return internalShape(source, sourceStart, sourceLength, dest, destStart, destSize);
    }

    /**
     * Convert a range of text in place. This may only be used if the Length option does not grow or
     * shrink the text.
     *
     * @param source An array containing the input text
     * @param start The start of the range of text to convert
     * @param length The length of the range of text to convert
     * @throws ArabicShapingException if the text cannot be converted according to the options.
     * @stable ICU 2.0
     */
    public void shape(char[] source, int start, int length) throws ArabicShapingException {
        if ((options & LAMALEF_MASK) == LAMALEF_RESIZE) {
            throw new ArabicShapingException("Cannot shape in place with length option resize.");
        }
        shape(source, start, length, source, start, length);
    }

    /**
     * Convert a string, returning the new string.
     *
     * @param text the string to convert
     * @return the converted string
     * @throws ArabicShapingException if the string cannot be converted according to the options.
     * @stable ICU 2.0
     */
    public String shape(String text) throws ArabicShapingException {
        char[] src = text.toCharArray();
        char[] dest = src;
        if (((options & LAMALEF_MASK) == LAMALEF_RESIZE)
                && ((options & LETTERS_MASK) == LETTERS_UNSHAPE)) {

            dest = new char[src.length * 2]; // max
        }
        int len = shape(src, 0, src.length, dest, 0, dest.length);

        return new String(dest, 0, len);
    }

    /**
     * Construct ArabicShaping using the options flags. The flags are as follows:<br>
     * 'LENGTH' flags control whether the text can change size, and if not, how to maintain the size
     * of the text when LamAlef ligatures are formed or broken.<br>
     * 'TEXT_DIRECTION' flags control whether the text is read and written in visual order or in
     * logical order.<br>
     * 'LETTERS_SHAPE' flags control whether conversion is to or from presentation forms.<br>
     * 'DIGITS' flags control whether digits are shaped, and whether from European to Arabic-Indic
     * or vice-versa.<br>
     * 'DIGIT_TYPE' flags control whether standard or extended Arabic-Indic digits are used when
     * performing digit conversion.
     *
     * @stable ICU 2.0
     */
    public ArabicShaping(int options) {
        this.options = options;
        if ((options & DIGITS_MASK) > 0x80) {
            throw new IllegalArgumentException("bad DIGITS options");
        }

        isLogical = ((options & TEXT_DIRECTION_MASK) == TEXT_DIRECTION_LOGICAL);
        /* Validate options */
        spacesRelativeToTextBeginEnd =
                ((options & SPACES_RELATIVE_TO_TEXT_MASK) == SPACES_RELATIVE_TO_TEXT_BEGIN_END);
        if ((options & SHAPE_TAIL_TYPE_MASK) == SHAPE_TAIL_NEW_UNICODE) {
            tailChar = NEW_TAIL_CHAR;
        } else {
            tailChar = OLD_TAIL_CHAR;
        }
    }

    /* Seen Tail options */
    /**
     * Memory option: the result must have the same length as the source. Shaping mode: The SEEN
     * family character will expand into two characters using space near the SEEN family
     * character(i.e. the space after the character). if there are no spaces found,
     * ArabicShapingException will be thrown
     *
     * <p>De-shaping mode: Any Seen character followed by Tail character will be replaced by one
     * cell Seen and a space will replace the Tail. Affects: Seen options
     *
     * @stable ICU 4.2
     */
    public static final int SEEN_TWOCELL_NEAR = 0x200000;

    /**
     * Bit mask for Seen memory options.
     *
     * @stable ICU 4.2
     */
    public static final int SEEN_MASK = 0x700000;

    /* YehHamza options */
    /**
     * Memory option: the result must have the same length as the source. Shaping mode: The YEHHAMZA
     * character will expand into two characters using space near it (i.e. the space after the
     * character) if there are no spaces found, ArabicShapingException will be thrown
     *
     * <p>De-shaping mode: Any Yeh (final or isolated) character followed by Hamza character will be
     * replaced by one cell YehHamza and space will replace the Hamza. Affects: YehHamza options
     *
     * @stable ICU 4.2
     */
    public static final int YEHHAMZA_TWOCELL_NEAR = 0x1000000;

    /**
     * Bit mask for YehHamza memory options.
     *
     * @stable ICU 4.2
     */
    public static final int YEHHAMZA_MASK = 0x3800000;

    /* New Tashkeel options */
    /**
     * Memory option: the result must have the same length as the source. Shaping mode: Tashkeel
     * characters will be replaced by spaces. Spaces will be placed at beginning of the buffer
     *
     * <p>De-shaping mode: N/A Affects: Tashkeel options
     *
     * @stable ICU 4.2
     */
    public static final int TASHKEEL_BEGIN = 0x40000;

    /**
     * Memory option: the result must have the same length as the source. Shaping mode: Tashkeel
     * characters will be replaced by spaces. Spaces will be placed at end of the buffer
     *
     * <p>De-shaping mode: N/A Affects: Tashkeel options
     *
     * @stable ICU 4.2
     */
    public static final int TASHKEEL_END = 0x60000;

    /**
     * Memory option: allow the result to have a different length than the source. Shaping mode:
     * Tashkeel characters will be removed, buffer length will shrink. De-shaping mode: N/A
     *
     * <p>Affects: Tashkeel options
     *
     * @stable ICU 4.2
     */
    public static final int TASHKEEL_RESIZE = 0x80000;

    /**
     * Memory option: the result must have the same length as the source. Shaping mode: Tashkeel
     * characters will be replaced by Tatweel if it is connected to adjacent characters (i.e. shaped
     * on Tatweel) or replaced by space if it is not connected.
     *
     * <p>De-shaping mode: N/A Affects: YehHamza options
     *
     * @stable ICU 4.2
     */
    public static final int TASHKEEL_REPLACE_BY_TATWEEL = 0xC0000;

    /**
     * Bit mask for Tashkeel replacement with Space or Tatweel memory options.
     *
     * @stable ICU 4.2
     */
    public static final int TASHKEEL_MASK = 0xE0000;

    /* Space location Control options */
    /**
     * This option effects the meaning of BEGIN and END options. if this option is not used the
     * default for BEGIN and END will be as following: The Default (for both Visual LTR, Visual RTL
     * and Logical Text) 1. BEGIN always refers to the start address of physical memory. 2. END
     * always refers to the end address of physical memory.
     *
     * <p>If this option is used it will swap the meaning of BEGIN and END only for Visual LTR text.
     *
     * <p>The affect on BEGIN and END Memory Options will be as following: A. BEGIN For Visual LTR
     * text: This will be the beginning (right side) of the visual text (corresponding to the
     * physical memory address end, same as END in default behavior) B. BEGIN For Logical text: Same
     * as BEGIN in default behavior. C. END For Visual LTR text: This will be the end (left side) of
     * the visual text. (corresponding to the physical memory address beginning, same as BEGIN in
     * default behavior) D. END For Logical text: Same as END in default behavior. Affects: All
     * LamAlef BEGIN, END and AUTO options.
     *
     * @stable ICU 4.2
     */
    public static final int SPACES_RELATIVE_TO_TEXT_BEGIN_END = 0x4000000;

    /**
     * Bit mask for swapping BEGIN and END for Visual LTR text
     *
     * @stable ICU 4.2
     */
    public static final int SPACES_RELATIVE_TO_TEXT_MASK = 0x4000000;

    /**
     * If this option is used, shaping will use the new Unicode code point for TAIL (i.e. 0xFE73).
     * If this option is not specified (Default), old unofficial Unicode TAIL code point is used
     * (i.e. 0x200B) De-shaping will not use this option as it will always search for both the new
     * Unicode code point for the TAIL (i.e. 0xFE73) or the old unofficial Unicode TAIL code point
     * (i.e. 0x200B) and de-shape the Seen-Family letter accordingly.
     *
     * <p>Shaping Mode: Only shaping. De-shaping Mode: N/A. Affects: All Seen options
     *
     * @stable ICU 4.2
     */
    public static final int SHAPE_TAIL_NEW_UNICODE = 0x8000000;

    /**
     * Bit mask for new Unicode Tail option
     *
     * @stable ICU 4.2
     */
    public static final int SHAPE_TAIL_TYPE_MASK = 0x8000000;

    /**
     * Memory option: allow the result to have a different length than the source.
     *
     * @stable ICU 2.0
     */
    public static final int LENGTH_GROW_SHRINK = 0;

    /**
     * Memory option: allow the result to have a different length than the source. Affects: LamAlef
     * options This option is an alias to LENGTH_GROW_SHRINK
     *
     * @stable ICU 4.2
     */
    public static final int LAMALEF_RESIZE = 0;

    /**
     * Memory option: the result must have the same length as the source. If more room is necessary,
     * then try to consume spaces next to modified characters.
     *
     * @stable ICU 2.0
     */
    public static final int LENGTH_FIXED_SPACES_NEAR = 1;

    /**
     * Memory option: the result must have the same length as the source. If more room is necessary,
     * then try to consume spaces next to modified characters. Affects: LamAlef options This option
     * is an alias to LENGTH_FIXED_SPACES_NEAR
     *
     * @stable ICU 4.2
     */
    public static final int LAMALEF_NEAR = 1;

    /**
     * Memory option: the result must have the same length as the source. If more room is necessary,
     * then try to consume spaces at the end of the text.
     *
     * @stable ICU 2.0
     */
    public static final int LENGTH_FIXED_SPACES_AT_END = 2;

    /**
     * Memory option: the result must have the same length as the source. If more room is necessary,
     * then try to consume spaces at the end of the text. Affects: LamAlef options This option is an
     * alias to LENGTH_FIXED_SPACES_AT_END
     *
     * @stable ICU 4.2
     */
    public static final int LAMALEF_END = 2;

    /**
     * Memory option: the result must have the same length as the source. If more room is necessary,
     * then try to consume spaces at the beginning of the text.
     *
     * @stable ICU 2.0
     */
    public static final int LENGTH_FIXED_SPACES_AT_BEGINNING = 3;

    /**
     * Memory option: the result must have the same length as the source. If more room is necessary,
     * then try to consume spaces at the beginning of the text. Affects: LamAlef options This option
     * is an alias to LENGTH_FIXED_SPACES_AT_BEGINNING
     *
     * @stable ICU 4.2
     */
    public static final int LAMALEF_BEGIN = 3;

    /**
     * Memory option: the result must have the same length as the source. Shaping Mode: For each
     * LAMALEF character found, expand LAMALEF using space at end. If there is no space at end, use
     * spaces at beginning of the buffer. If there is no space at beginning of the buffer, use
     * spaces at the near (i.e. the space after the LAMALEF character).
     *
     * <p>Deshaping Mode: Perform the same function as the flag equals LAMALEF_END. Affects: LamAlef
     * options
     *
     * @stable ICU 4.2
     */
    public static final int LAMALEF_AUTO = 0x10000;

    /**
     * Bit mask for memory options.
     *
     * @stable ICU 2.0
     */
    public static final int LENGTH_MASK = 0x10003;

    /**
     * Bit mask for LamAlef memory options.
     *
     * @stable ICU 4.2
     */
    public static final int LAMALEF_MASK = 0x10003;

    /**
     * Direction indicator: the source is in logical (keyboard) order.
     *
     * @stable ICU 2.0
     */
    public static final int TEXT_DIRECTION_LOGICAL = 0;

    /**
     * Direction indicator:the source is in visual RTL order, the rightmost displayed character
     * stored first. This option is an alias to U_SHAPE_TEXT_DIRECTION_LOGICAL
     *
     * @stable ICU 4.2
     */
    public static final int TEXT_DIRECTION_VISUAL_RTL = 0;

    /**
     * Direction indicator: the source is in visual (display) order, that is, the leftmost displayed
     * character is stored first.
     *
     * @stable ICU 2.0
     */
    public static final int TEXT_DIRECTION_VISUAL_LTR = 4;

    /**
     * Bit mask for direction indicators.
     *
     * @stable ICU 2.0
     */
    public static final int TEXT_DIRECTION_MASK = 4;

    /**
     * Letter shaping option: do not perform letter shaping.
     *
     * @stable ICU 2.0
     */
    public static final int LETTERS_NOOP = 0;

    /**
     * Letter shaping option: replace normative letter characters in the U+0600 (Arabic) block, by
     * shaped ones in the U+FE70 (Presentation Forms B) block. Performs Lam-Alef ligature
     * substitution.
     *
     * @stable ICU 2.0
     */
    public static final int LETTERS_SHAPE = 8;

    /**
     * Letter shaping option: replace shaped letter characters in the U+FE70 (Presentation Forms B)
     * block by normative ones in the U+0600 (Arabic) block. Converts Lam-Alef ligatures to pairs of
     * Lam and Alef characters, consuming spaces if required.
     *
     * @stable ICU 2.0
     */
    public static final int LETTERS_UNSHAPE = 0x10;

    /**
     * Letter shaping option: replace normative letter characters in the U+0600 (Arabic) block,
     * except for the TASHKEEL characters at U+064B...U+0652, by shaped ones in the U+Fe70
     * (Presentation Forms B) block. The TASHKEEL characters will always be converted to the
     * isolated forms rather than to their correct shape.
     *
     * @stable ICU 2.0
     */
    public static final int LETTERS_SHAPE_TASHKEEL_ISOLATED = 0x18;

    /**
     * Bit mask for letter shaping options.
     *
     * @stable ICU 2.0
     */
    public static final int LETTERS_MASK = 0x18;

    /**
     * Digit shaping option: do not perform digit shaping.
     *
     * @stable ICU 2.0
     */
    public static final int DIGITS_NOOP = 0;

    /**
     * Digit shaping option: Replace European digits (U+0030...U+0039) by Arabic-Indic digits.
     *
     * @stable ICU 2.0
     */
    public static final int DIGITS_EN2AN = 0x20;

    /**
     * Digit shaping option: Replace Arabic-Indic digits by European digits (U+0030...U+0039).
     *
     * @stable ICU 2.0
     */
    public static final int DIGITS_AN2EN = 0x40;

    /**
     * Digit shaping option: Replace European digits (U+0030...U+0039) by Arabic-Indic digits if the
     * most recent strongly directional character is an Arabic letter (its Bidi direction value is
     * RIGHT_TO_LEFT_ARABIC). The initial state at the start of the text is assumed to be not an
     * Arabic, letter, so European digits at the start of the text will not change. Compare to
     * DIGITS_ALEN2AN_INIT_AL.
     *
     * @stable ICU 2.0
     */
    public static final int DIGITS_EN2AN_INIT_LR = 0x60;

    /**
     * Digit shaping option: Replace European digits (U+0030...U+0039) by Arabic-Indic digits if the
     * most recent strongly directional character is an Arabic letter (its Bidi direction value is
     * RIGHT_TO_LEFT_ARABIC). The initial state at the start of the text is assumed to be an Arabic,
     * letter, so European digits at the start of the text will change. Compare to
     * DIGITS_ALEN2AN_INT_LR.
     *
     * @stable ICU 2.0
     */
    public static final int DIGITS_EN2AN_INIT_AL = 0x80;

    /** Not a valid option value. */
    // private static final int DIGITS_RESERVED = 0xa0;

    /**
     * Bit mask for digit shaping options.
     *
     * @stable ICU 2.0
     */
    public static final int DIGITS_MASK = 0xe0;

    /**
     * Digit type option: Use Arabic-Indic digits (U+0660...U+0669).
     *
     * @stable ICU 2.0
     */
    public static final int DIGIT_TYPE_AN = 0;

    /**
     * Digit type option: Use Eastern (Extended) Arabic-Indic digits (U+06f0...U+06f9).
     *
     * @stable ICU 2.0
     */
    public static final int DIGIT_TYPE_AN_EXTENDED = 0x100;

    /**
     * Bit mask for digit type options.
     *
     * @stable ICU 2.0
     */
    public static final int DIGIT_TYPE_MASK = 0x0100; // 0x3f00?

    /** some constants */
    private static final char HAMZAFE_CHAR = '\ufe80';

    private static final char HAMZA06_CHAR = '\u0621';
    private static final char YEH_HAMZA_CHAR = '\u0626';
    private static final char YEH_HAMZAFE_CHAR = '\uFE89';
    private static final char LAMALEF_SPACE_SUB = '\uffff';
    private static final char TASHKEEL_SPACE_SUB = '\ufffe';
    private static final char LAM_CHAR = '\u0644';
    private static final char SPACE_CHAR = '\u0020';
    private static final char SHADDA_CHAR = '\uFE7C';
    private static final char SHADDA06_CHAR = '\u0651';
    private static final char TATWEEL_CHAR = '\u0640';
    private static final char SHADDA_TATWEEL_CHAR = '\uFE7D';
    private static final char NEW_TAIL_CHAR = '\uFE73';
    private static final char OLD_TAIL_CHAR = '\u200B';
    private static final int SHAPE_MODE = 0;
    private static final int DESHAPE_MODE = 1;

    /**
     * @stable ICU 2.0
     */
    @Override
    public boolean equals(Object rhs) {
        return rhs != null
                && rhs.getClass() == ArabicShaping.class
                && options == ((ArabicShaping) rhs).options;
    }

    /**
     * @stable ICU 2.0
     */
    /// CLOVER:OFF
    @Override
    public int hashCode() {
        return options;
    }

    /**
     * @stable ICU 2.0
     */
    @Override
    public String toString() {
        StringBuilder buf = new StringBuilder(super.toString());
        buf.append('[');

        switch (options & LAMALEF_MASK) {
            case LAMALEF_RESIZE:
                buf.append("LamAlef resize");
                break;
            case LAMALEF_NEAR:
                buf.append("LamAlef spaces at near");
                break;
            case LAMALEF_BEGIN:
                buf.append("LamAlef spaces at begin");
                break;
            case LAMALEF_END:
                buf.append("LamAlef spaces at end");
                break;
            case LAMALEF_AUTO:
                buf.append("lamAlef auto");
                break;
        }
        switch (options & TEXT_DIRECTION_MASK) {
            case TEXT_DIRECTION_LOGICAL:
                buf.append(", logical");
                break;
            case TEXT_DIRECTION_VISUAL_LTR:
                buf.append(", visual");
                break;
        }
        switch (options & LETTERS_MASK) {
            case LETTERS_NOOP:
                buf.append(", no letter shaping");
                break;
            case LETTERS_SHAPE:
                buf.append(", shape letters");
                break;
            case LETTERS_SHAPE_TASHKEEL_ISOLATED:
                buf.append(", shape letters tashkeel isolated");
                break;
            case LETTERS_UNSHAPE:
                buf.append(", unshape letters");
                break;
        }
        switch (options & SEEN_MASK) {
            case SEEN_TWOCELL_NEAR:
                buf.append(", Seen at near");
                break;
        }
        switch (options & YEHHAMZA_MASK) {
            case YEHHAMZA_TWOCELL_NEAR:
                buf.append(", Yeh Hamza at near");
                break;
        }
        switch (options & TASHKEEL_MASK) {
            case TASHKEEL_BEGIN:
                buf.append(", Tashkeel at begin");
                break;
            case TASHKEEL_END:
                buf.append(", Tashkeel at end");
                break;
            case TASHKEEL_REPLACE_BY_TATWEEL:
                buf.append(", Tashkeel replace with tatweel");
                break;
            case TASHKEEL_RESIZE:
                buf.append(", Tashkeel resize");
                break;
        }

        switch (options & DIGITS_MASK) {
            case DIGITS_NOOP:
                buf.append(", no digit shaping");
                break;
            case DIGITS_EN2AN:
                buf.append(", shape digits to AN");
                break;
            case DIGITS_AN2EN:
                buf.append(", shape digits to EN");
                break;
            case DIGITS_EN2AN_INIT_LR:
                buf.append(", shape digits to AN contextually: default EN");
                break;
            case DIGITS_EN2AN_INIT_AL:
                buf.append(", shape digits to AN contextually: default AL");
                break;
        }
        switch (options & DIGIT_TYPE_MASK) {
            case DIGIT_TYPE_AN:
                buf.append(", standard Arabic-Indic digits");
                break;
            case DIGIT_TYPE_AN_EXTENDED:
                buf.append(", extended Arabic-Indic digits");
                break;
        }
        buf.append("]");

        return buf.toString();
    }

    /// CLOVER:ON

    //
    // ported api
    //

    private static final int IRRELEVANT = 4;
    private static final int LAMTYPE = 16;
    private static final int ALEFTYPE = 32;

    private static final int LINKR = 1;
    private static final int LINKL = 2;
    private static final int LINK_MASK = 3;

    private static final int irrelevantPos[] = {0x0, 0x2, 0x4, 0x6, 0x8, 0xA, 0xC, 0xE};

    /*
        private static final char convertLamAlef[] =  {
            '\u0622', // FEF5
            '\u0622', // FEF6
            '\u0623', // FEF7
            '\u0623', // FEF8
            '\u0625', // FEF9
            '\u0625', // FEFA
            '\u0627', // FEFB
            '\u0627'  // FEFC
        };
    */

    private static final int tailFamilyIsolatedFinal[] = {
        /* FEB1 */ 1,
        /* FEB2 */ 1,
        /* FEB3 */ 0,
        /* FEB4 */ 0,
        /* FEB5 */ 1,
        /* FEB6 */ 1,
        /* FEB7 */ 0,
        /* FEB8 */ 0,
        /* FEB9 */ 1,
        /* FEBA */ 1,
        /* FEBB */ 0,
        /* FEBC */ 0,
        /* FEBD */ 1,
        /* FEBE */ 1
    };

    private static final int tashkeelMedial[] = {
        /* FE70 */ 0,
        /* FE71 */ 1,
        /* FE72 */ 0,
        /* FE73 */ 0,
        /* FE74 */ 0,
        /* FE75 */ 0,
        /* FE76 */ 0,
        /* FE77 */ 1,
        /* FE78 */ 0,
        /* FE79 */ 1,
        /* FE7A */ 0,
        /* FE7B */ 1,
        /* FE7C */ 0,
        /* FE7D */ 1,
        /* FE7E */ 0,
        /* FE7F */ 1
    };

    private static final char yehHamzaToYeh[] = {
        /* isolated*/
        0xFEEF, /* final   */ 0xFEF0
    };

    private static final char convertNormalizedLamAlef[] = {
        '\u0622', // 065C
        '\u0623', // 065D
        '\u0625', // 065E
        '\u0627', // 065F
    };

    private static final int[] araLink = {
        1 + 32 + 256 * 0x11, /*0x0622*/
        1 + 32 + 256 * 0x13, /*0x0623*/
        1 + 256 * 0x15, /*0x0624*/
        1 + 32 + 256 * 0x17, /*0x0625*/
        1 + 2 + 256 * 0x19, /*0x0626*/
        1 + 32 + 256 * 0x1D, /*0x0627*/
        1 + 2 + 256 * 0x1F, /*0x0628*/
        1 + 256 * 0x23, /*0x0629*/
        1 + 2 + 256 * 0x25, /*0x062A*/
        1 + 2 + 256 * 0x29, /*0x062B*/
        1 + 2 + 256 * 0x2D, /*0x062C*/
        1 + 2 + 256 * 0x31, /*0x062D*/
        1 + 2 + 256 * 0x35, /*0x062E*/
        1 + 256 * 0x39, /*0x062F*/
        1 + 256 * 0x3B, /*0x0630*/
        1 + 256 * 0x3D, /*0x0631*/
        1 + 256 * 0x3F, /*0x0632*/
        1 + 2 + 256 * 0x41, /*0x0633*/
        1 + 2 + 256 * 0x45, /*0x0634*/
        1 + 2 + 256 * 0x49, /*0x0635*/
        1 + 2 + 256 * 0x4D, /*0x0636*/
        1 + 2 + 256 * 0x51, /*0x0637*/
        1 + 2 + 256 * 0x55, /*0x0638*/
        1 + 2 + 256 * 0x59, /*0x0639*/
        1 + 2 + 256 * 0x5D, /*0x063A*/
        0,
        0,
        0,
        0,
        0, /*0x063B-0x063F*/
        1 + 2, /*0x0640*/
        1 + 2 + 256 * 0x61, /*0x0641*/
        1 + 2 + 256 * 0x65, /*0x0642*/
        1 + 2 + 256 * 0x69, /*0x0643*/
        1 + 2 + 16 + 256 * 0x6D, /*0x0644*/
        1 + 2 + 256 * 0x71, /*0x0645*/
        1 + 2 + 256 * 0x75, /*0x0646*/
        1 + 2 + 256 * 0x79, /*0x0647*/
        1 + 256 * 0x7D, /*0x0648*/
        1 + 256 * 0x7F, /*0x0649*/
        1 + 2 + 256 * 0x81, /*0x064A*/
        4,
        4,
        4,
        4, /*0x064B-0x064E*/
        4,
        4,
        4,
        4, /*0x064F-0x0652*/
        4,
        4,
        4,
        0,
        0, /*0x0653-0x0657*/
        0,
        0,
        0,
        0, /*0x0658-0x065B*/
        1 + 256 * 0x85, /*0x065C*/
        1 + 256 * 0x87, /*0x065D*/
        1 + 256 * 0x89, /*0x065E*/
        1 + 256 * 0x8B, /*0x065F*/
        0,
        0,
        0,
        0,
        0, /*0x0660-0x0664*/
        0,
        0,
        0,
        0,
        0, /*0x0665-0x0669*/
        0,
        0,
        0,
        0,
        0,
        0, /*0x066A-0x066F*/
        4, /*0x0670*/
        0, /*0x0671*/
        1 + 32, /*0x0672*/
        1 + 32, /*0x0673*/
        0, /*0x0674*/
        1 + 32, /*0x0675*/
        1,
        1, /*0x0676-0x0677*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0x0678-0x067D*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0x067E-0x0683*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0x0684-0x0687*/
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1, /*0x0688-0x0691*/
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1, /*0x0692-0x0699*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0x069A-0x06A3*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0x069A-0x06A3*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0x06A4-0x06AD*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0x06A4-0x06AD*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0x06AE-0x06B7*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0x06AE-0x06B7*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0x06B8-0x06BF*/
        1 + 2,
        1 + 2, /*0x06B8-0x06BF*/
        1, /*0x06C0*/
        1 + 2, /*0x06C1*/
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1, /*0x06C2-0x06CB*/
        1 + 2, /*0x06CC*/
        1, /*0x06CD*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0x06CE-0x06D1*/
        1,
        1 /*0x06D2-0x06D3*/
    };

    private static final int[] presLink = {
        1 + 2, /*0xFE70*/
        1 + 2, /*0xFE71*/
        1 + 2,
        0,
        1 + 2,
        0,
        1 + 2, /*0xFE72-0xFE76*/
        1 + 2, /*0xFE77*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0xFE78-0xFE81*/
        1 + 2,
        1 + 2,
        1 + 2,
        1 + 2, /*0xFE82-0xFE85*/
        0,
        0 + 32,
        1 + 32,
        0 + 32, /*0xFE86-0xFE89*/
        1 + 32,
        0,
        1,
        0 + 32, /*0xFE8A-0xFE8D*/
        1 + 32,
        0,
        2,
        1 + 2, /*0xFE8E-0xFE91*/
        1,
        0 + 32,
        1 + 32,
        0, /*0xFE92-0xFE95*/
        2,
        1 + 2,
        1,
        0, /*0xFE96-0xFE99*/
        1,
        0,
        2,
        1 + 2, /*0xFE9A-0xFE9D*/
        1,
        0,
        2,
        1 + 2, /*0xFE9E-0xFEA1*/
        1,
        0,
        2,
        1 + 2, /*0xFEA2-0xFEA5*/
        1,
        0,
        2,
        1 + 2, /*0xFEA6-0xFEA9*/
        1,
        0,
        2,
        1 + 2, /*0xFEAA-0xFEAD*/
        1,
        0,
        1,
        0, /*0xFEAE-0xFEB1*/
        1,
        0,
        1,
        0, /*0xFEB2-0xFEB5*/
        1,
        0,
        2,
        1 + 2, /*0xFEB6-0xFEB9*/
        1,
        0,
        2,
        1 + 2, /*0xFEBA-0xFEBD*/
        1,
        0,
        2,
        1 + 2, /*0xFEBE-0xFEC1*/
        1,
        0,
        2,
        1 + 2, /*0xFEC2-0xFEC5*/
        1,
        0,
        2,
        1 + 2, /*0xFEC6-0xFEC9*/
        1,
        0,
        2,
        1 + 2, /*0xFECA-0xFECD*/
        1,
        0,
        2,
        1 + 2, /*0xFECE-0xFED1*/
        1,
        0,
        2,
        1 + 2, /*0xFED2-0xFED5*/
        1,
        0,
        2,
        1 + 2, /*0xFED6-0xFED9*/
        1,
        0,
        2,
        1 + 2, /*0xFEDA-0xFEDD*/
        1,
        0,
        2,
        1 + 2, /*0xFEDE-0xFEE1*/
        1,
        0 + 16,
        2 + 16,
        1 + 2 + 16, /*0xFEE2-0xFEE5*/
        1 + 16,
        0,
        2,
        1 + 2, /*0xFEE6-0xFEE9*/
        1,
        0,
        2,
        1 + 2, /*0xFEEA-0xFEED*/
        1,
        0,
        2,
        1 + 2, /*0xFEEE-0xFEF1*/
        1,
        0,
        1,
        0, /*0xFEF2-0xFEF5*/
        1,
        0,
        2,
        1 + 2, /*0xFEF6-0xFEF9*/
        1,
        0,
        1,
        0, /*0xFEFA-0xFEFD*/
        1,
        0,
        1,
        0,
        1
    };

    private static int[] convertFEto06 = {
        /***********0******1******2******3******4******5******6******7******8******9******A******B******C******D******E******F***/
        /*FE7*/ 0x64B,
        0x64B,
        0x64C,
        0x64C,
        0x64D,
        0x64D,
        0x64E,
        0x64E,
        0x64F,
        0x64F,
        0x650,
        0x650,
        0x651,
        0x651,
        0x652,
        0x652,
        /*FE8*/ 0x621,
        0x622,
        0x622,
        0x623,
        0x623,
        0x624,
        0x624,
        0x625,
        0x625,
        0x626,
        0x626,
        0x626,
        0x626,
        0x627,
        0x627,
        0x628,
        /*FE9*/ 0x628,
        0x628,
        0x628,
        0x629,
        0x629,
        0x62A,
        0x62A,
        0x62A,
        0x62A,
        0x62B,
        0x62B,
        0x62B,
        0x62B,
        0x62C,
        0x62C,
        0x62C,
        /*FEA*/ 0x62C,
        0x62D,
        0x62D,
        0x62D,
        0x62D,
        0x62E,
        0x62E,
        0x62E,
        0x62E,
        0x62F,
        0x62F,
        0x630,
        0x630,
        0x631,
        0x631,
        0x632,
        /*FEB*/ 0x632,
        0x633,
        0x633,
        0x633,
        0x633,
        0x634,
        0x634,
        0x634,
        0x634,
        0x635,
        0x635,
        0x635,
        0x635,
        0x636,
        0x636,
        0x636,
        /*FEC*/ 0x636,
        0x637,
        0x637,
        0x637,
        0x637,
        0x638,
        0x638,
        0x638,
        0x638,
        0x639,
        0x639,
        0x639,
        0x639,
        0x63A,
        0x63A,
        0x63A,
        /*FED*/ 0x63A,
        0x641,
        0x641,
        0x641,
        0x641,
        0x642,
        0x642,
        0x642,
        0x642,
        0x643,
        0x643,
        0x643,
        0x643,
        0x644,
        0x644,
        0x644,
        /*FEE*/ 0x644,
        0x645,
        0x645,
        0x645,
        0x645,
        0x646,
        0x646,
        0x646,
        0x646,
        0x647,
        0x647,
        0x647,
        0x647,
        0x648,
        0x648,
        0x649,
        /*FEF*/ 0x649,
        0x64A,
        0x64A,
        0x64A,
        0x64A,
        0x65C,
        0x65C,
        0x65D,
        0x65D,
        0x65E,
        0x65E,
        0x65F,
        0x65F
    };

    private static final int shapeTable[][][] = {
        {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 1, 0, 3}, {0, 1, 0, 1}},
        {{0, 0, 2, 2}, {0, 0, 1, 2}, {0, 1, 1, 2}, {0, 1, 1, 3}},
        {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 1, 0, 3}, {0, 1, 0, 3}},
        {{0, 0, 1, 2}, {0, 0, 1, 2}, {0, 1, 1, 2}, {0, 1, 1, 3}}
    };

    /*
     * This function shapes European digits to Arabic-Indic digits
     * in-place, writing over the input characters.  Data is in visual
     * order.
     */
    private void shapeToArabicDigitsWithContext(
            char[] dest, int start, int length, char digitBase, boolean lastStrongWasAL) {
        UBiDiProps bdp = UBiDiProps.INSTANCE;
        digitBase -= '0'; // move common adjustment out of loop

        for (int i = start + length; --i >= start; ) {
            char ch = dest[i];
            switch (bdp.getClass(ch)) {
                case UCharacterDirection.LEFT_TO_RIGHT:
                case UCharacterDirection.RIGHT_TO_LEFT:
                    lastStrongWasAL = false;
                    break;
                case UCharacterDirection.RIGHT_TO_LEFT_ARABIC:
                    lastStrongWasAL = true;
                    break;
                case UCharacterDirection.EUROPEAN_NUMBER:
                    if (lastStrongWasAL && ch <= '\u0039') {
                        dest[i] = (char) (ch + digitBase);
                    }
                    break;
                default:
                    break;
            }
        }
    }

    /*
     * Name    : invertBuffer
     * Function: This function inverts the buffer, it's used
     *           in case the user specifies the buffer to be
     *           TEXT_DIRECTION_LOGICAL
     */
    private static void invertBuffer(char[] buffer, int start, int length) {

        for (int i = start, j = start + length - 1; i < j; i++, --j) {
            char temp = buffer[i];
            buffer[i] = buffer[j];
            buffer[j] = temp;
        }
    }

    /*
     * Name    : changeLamAlef
     * Function: Converts the Alef characters into an equivalent
     *           LamAlef location in the 0x06xx Range, this is an
     *           intermediate stage in the operation of the program
     *           later it'll be converted into the 0xFExx LamAlefs
     *           in the shaping function.
     */
    private static char changeLamAlef(char ch) {
        switch (ch) {
            case '\u0622':
                return '\u065C';
            case '\u0623':
                return '\u065D';
            case '\u0625':
                return '\u065E';
            case '\u0627':
                return '\u065F';
            default:
                return '\u0000'; // not a lamalef
        }
    }

    /*
     * Name    : specialChar
     * Function: Special Arabic characters need special handling in the shapeUnicode
     *           function, this function returns 1 or 2 for these special characters
     */
    private static int specialChar(char ch) {
        if ((ch > '\u0621' && ch < '\u0626')
                || (ch == '\u0627')
                || (ch > '\u062E' && ch < '\u0633')
                || (ch > '\u0647' && ch < '\u064A')
                || (ch == '\u0629')) {
            return 1;
        } else if (ch >= '\u064B' && ch <= '\u0652') {
            return 2;
        } else if (ch >= 0x0653 && ch <= 0x0655 || ch == 0x0670 || ch >= 0xFE70 && ch <= 0xFE7F) {
            return 3;
        } else {
            return 0;
        }
    }

    /*
     * Name    : getLink
     * Function: Resolves the link between the characters as
     *           Arabic characters have four forms :
     *           Isolated, Initial, Middle and Final Form
     */
    private static int getLink(char ch) {
        if (ch >= '\u0622' && ch <= '\u06D3') {
            return araLink[ch - '\u0622'];
        } else if (ch == '\u200D') {
            return 3;
        } else if (ch >= '\u206D' && ch <= '\u206F') {
            return 4;
        } else if (ch >= '\uFE70' && ch <= '\uFEFC') {
            return presLink[ch - '\uFE70'];
        } else {
            return 0;
        }
    }

    /*
     * Name    : countSpaces
     * Function: Counts the number of spaces
     *           at each end of the logical buffer
     */
    private static int countSpacesLeft(char[] dest, int start, int count) {
        for (int i = start, e = start + count; i < e; ++i) {
            if (dest[i] != SPACE_CHAR) {
                return i - start;
            }
        }
        return count;
    }

    private static int countSpacesRight(char[] dest, int start, int count) {

        for (int i = start + count; --i >= start; ) {
            if (dest[i] != SPACE_CHAR) {
                return start + count - 1 - i;
            }
        }
        return count;
    }

    /*
     * Name    : isTashkeelChar
     * Function: Returns true for Tashkeel characters else return false
     */
    private static boolean isTashkeelChar(char ch) {
        return (ch >= '\u064B' && ch <= '\u0652');
    }

    /*
     *Name     : isSeenTailFamilyChar
     *Function : returns 1 if the character is a seen family isolated character
     *           in the FE range otherwise returns 0
     */

    private static int isSeenTailFamilyChar(char ch) {
        if (ch >= 0xfeb1 && ch < 0xfebf) {
            return tailFamilyIsolatedFinal[ch - 0xFEB1];
        } else {
            return 0;
        }
    }

    /* Name     : isSeenFamilyChar
     * Function : returns 1 if the character is a seen family character in the Unicode
     *            06 range otherwise returns 0
     */

    private static int isSeenFamilyChar(char ch) {
        if (ch >= 0x633 && ch <= 0x636) {
            return 1;
        } else {
            return 0;
        }
    }

    /*
     *Name     : isTailChar
     *Function : returns true if the character matches one of the tail characters
     *           (0xfe73 or 0x200b) otherwise returns false
     */

    private static boolean isTailChar(char ch) {
        if (ch == OLD_TAIL_CHAR || ch == NEW_TAIL_CHAR) {
            return true;
        } else {
            return false;
        }
    }

    /*
     *Name     : isAlefMaksouraChar
     *Function : returns true if the character is a Alef Maksoura Final or isolated
     *           otherwise returns false
     */
    private static boolean isAlefMaksouraChar(char ch) {
        return ((ch == 0xFEEF) || (ch == 0xFEF0) || (ch == 0x0649));
    }

    /*
     * Name     : isYehHamzaChar
     * Function : returns true if the character is a yehHamza isolated or yehhamza
     *            final is found otherwise returns false
     */
    private static boolean isYehHamzaChar(char ch) {
        if ((ch == 0xFE89) || (ch == 0xFE8A)) {
            return true;
        } else {
            return false;
        }
    }

    /*
     *Name     : isTashkeelCharFE
     *Function : Returns true for Tashkeel characters in FE range else return false
     */

    private static boolean isTashkeelCharFE(char ch) {
        return (ch != 0xFE75 && (ch >= 0xFE70 && ch <= 0xFE7F));
    }

    /*
     * Name: isTashkeelOnTatweelChar
     * Function: Checks if the Tashkeel Character is on Tatweel or not,if the
     *           Tashkeel on tatweel (FE range), it returns 1 else if the
     *           Tashkeel with shadda on tatweel (FC range)return 2 otherwise
     *           returns 0
     */
    private static int isTashkeelOnTatweelChar(char ch) {
        if (ch >= 0xfe70
                && ch <= 0xfe7f
                && ch != NEW_TAIL_CHAR
                && ch != 0xFE75
                && ch != SHADDA_TATWEEL_CHAR) {
            return tashkeelMedial[ch - 0xFE70];
        } else if ((ch >= 0xfcf2 && ch <= 0xfcf4) || (ch == SHADDA_TATWEEL_CHAR)) {
            return 2;
        } else {
            return 0;
        }
    }

    /*
     * Name: isIsolatedTashkeelChar
     * Function: Checks if the Tashkeel Character is in the isolated form
     *           (i.e. Unicode FE range) returns 1 else if the Tashkeel
     *           with shadda is in the isolated form (i.e. Unicode FC range)
     *           returns 1 otherwise returns 0
     */
    private static int isIsolatedTashkeelChar(char ch) {
        if (ch >= 0xfe70 && ch <= 0xfe7f && ch != NEW_TAIL_CHAR && ch != 0xFE75) {
            return (1 - tashkeelMedial[ch - 0xFE70]);
        } else if (ch >= 0xfc5e && ch <= 0xfc63) {
            return 1;
        } else {
            return 0;
        }
    }

    /*
     * Name    : isAlefChar
     * Function: Returns 1 for Alef characters else return 0
     */
    private static boolean isAlefChar(char ch) {
        return ch == '\u0622' || ch == '\u0623' || ch == '\u0625' || ch == '\u0627';
    }

    /*
     * Name    : isLamAlefChar
     * Function: Returns true for LamAlef characters else return false
     */
    private static boolean isLamAlefChar(char ch) {
        return ch >= '\uFEF5' && ch <= '\uFEFC';
    }

    private static boolean isNormalizedLamAlefChar(char ch) {
        return ch >= '\u065C' && ch <= '\u065F';
    }

    /*
     * Name    : calculateSize
     * Function: This function calculates the destSize to be used in preflighting
     *           when the destSize is equal to 0
     */
    private int calculateSize(char[] source, int sourceStart, int sourceLength) {

        int destSize = sourceLength;

        switch (options & LETTERS_MASK) {
            case LETTERS_SHAPE:
            case LETTERS_SHAPE_TASHKEEL_ISOLATED:
                if (isLogical) {
                    for (int i = sourceStart, e = sourceStart + sourceLength - 1; i < e; ++i) {
                        if ((source[i] == LAM_CHAR && isAlefChar(source[i + 1]))
                                || isTashkeelCharFE(source[i])) {
                            --destSize;
                        }
                    }
                } else { // visual
                    for (int i = sourceStart + 1, e = sourceStart + sourceLength; i < e; ++i) {
                        if ((source[i] == LAM_CHAR && isAlefChar(source[i - 1]))
                                || isTashkeelCharFE(source[i])) {
                            --destSize;
                        }
                    }
                }
                break;

            case LETTERS_UNSHAPE:
                for (int i = sourceStart, e = sourceStart + sourceLength; i < e; ++i) {
                    if (isLamAlefChar(source[i])) {
                        destSize++;
                    }
                }
                break;

            default:
                break;
        }

        return destSize;
    }

    /*
     * Name    : countSpaceSub
     * Function: Counts number of times the subChar appears in the array
     */
    private static int countSpaceSub(char[] dest, int length, char subChar) {
        int i = 0;
        int count = 0;
        while (i < length) {
            if (dest[i] == subChar) {
                count++;
            }
            i++;
        }
        return count;
    }

    /*
     * Name    : shiftArray
     * Function: Shifts characters to replace space sub characters
     */
    private static void shiftArray(char[] dest, int start, int e, char subChar) {
        int w = e;
        int r = e;
        while (--r >= start) {
            char ch = dest[r];
            if (ch != subChar) {
                --w;
                if (w != r) {
                    dest[w] = ch;
                }
            }
        }
    }

    /*
     * Name    : flipArray
     * Function: inverts array, so that start becomes end and vice versa
     */
    private static int flipArray(char[] dest, int start, int e, int w) {
        int r;
        if (w > start) {
            // shift, assume small buffer size so don't use arraycopy
            r = w;
            w = start;
            while (r < e) {
                dest[w++] = dest[r++];
            }
        } else {
            w = e;
        }
        return w;
    }

    /*
     * Name     : handleTashkeelWithTatweel
     * Function : Replaces Tashkeel as following:
     *            Case 1 :if the Tashkeel on tatweel, replace it with Tatweel.
     *            Case 2 :if the Tashkeel aggregated with Shadda on Tatweel, replace
     *                   it with Shadda on Tatweel.
     *            Case 3: if the Tashkeel is isolated replace it with Space.
     *
     */
    private static int handleTashkeelWithTatweel(char[] dest, int sourceLength) {
        int i;
        for (i = 0; i < sourceLength; i++) {
            if ((isTashkeelOnTatweelChar(dest[i]) == 1)) {
                dest[i] = TATWEEL_CHAR;
            } else if ((isTashkeelOnTatweelChar(dest[i]) == 2)) {
                dest[i] = SHADDA_TATWEEL_CHAR;
            } else if ((isIsolatedTashkeelChar(dest[i]) == 1) && dest[i] != SHADDA_CHAR) {
                dest[i] = SPACE_CHAR;
            }
        }
        return sourceLength;
    }

    /*
     *Name     : handleGeneratedSpaces
     *Function : The shapeUnicode function converts Lam + Alef into LamAlef + space,
     *           and Tashkeel to space.
     *           handleGeneratedSpaces function puts these generated spaces
     *           according to the options the user specifies. LamAlef and Tashkeel
     *           spaces can be replaced at begin, at end, at near or decrease the
     *           buffer size.
     *
     *           There is also Auto option for LamAlef and tashkeel, which will put
     *           the spaces at end of the buffer (or end of text if the user used
     *           the option SPACES_RELATIVE_TO_TEXT_BEGIN_END).
     *
     *           If the text type was visual_LTR and the option
     *           SPACES_RELATIVE_TO_TEXT_BEGIN_END was selected the END
     *           option will place the space at the beginning of the buffer and
     *           BEGIN will place the space at the end of the buffer.
     */
    private int handleGeneratedSpaces(char[] dest, int start, int length) {

        int lenOptionsLamAlef = options & LAMALEF_MASK;
        int lenOptionsTashkeel = options & TASHKEEL_MASK;
        boolean lamAlefOn = false;
        boolean tashkeelOn = false;

        if (!isLogical & !spacesRelativeToTextBeginEnd) {
            switch (lenOptionsLamAlef) {
                case LAMALEF_BEGIN:
                    lenOptionsLamAlef = LAMALEF_END;
                    break;
                case LAMALEF_END:
                    lenOptionsLamAlef = LAMALEF_BEGIN;
                    break;
                default:
                    break;
            }
            switch (lenOptionsTashkeel) {
                case TASHKEEL_BEGIN:
                    lenOptionsTashkeel = TASHKEEL_END;
                    break;
                case TASHKEEL_END:
                    lenOptionsTashkeel = TASHKEEL_BEGIN;
                    break;
                default:
                    break;
            }
        }

        if (lenOptionsLamAlef == LAMALEF_NEAR) {
            for (int i = start, e = i + length; i < e; ++i) {
                if (dest[i] == LAMALEF_SPACE_SUB) {
                    dest[i] = SPACE_CHAR;
                }
            }

        } else {

            final int e = start + length;
            int wL = countSpaceSub(dest, length, LAMALEF_SPACE_SUB);
            int wT = countSpaceSub(dest, length, TASHKEEL_SPACE_SUB);

            if (lenOptionsLamAlef == LAMALEF_END) {
                lamAlefOn = true;
            }
            if (lenOptionsTashkeel == TASHKEEL_END) {
                tashkeelOn = true;
            }

            if (lamAlefOn && (lenOptionsLamAlef == LAMALEF_END)) {
                shiftArray(dest, start, e, LAMALEF_SPACE_SUB);
                while (wL > start) {
                    dest[--wL] = SPACE_CHAR;
                }
            }

            if (tashkeelOn && (lenOptionsTashkeel == TASHKEEL_END)) {
                shiftArray(dest, start, e, TASHKEEL_SPACE_SUB);
                while (wT > start) {
                    dest[--wT] = SPACE_CHAR;
                }
            }

            lamAlefOn = false;
            tashkeelOn = false;

            if (lenOptionsLamAlef == LAMALEF_RESIZE) {
                lamAlefOn = true;
            }
            if (lenOptionsTashkeel == TASHKEEL_RESIZE) {
                tashkeelOn = true;
            }

            if (lamAlefOn && (lenOptionsLamAlef == LAMALEF_RESIZE)) {
                shiftArray(dest, start, e, LAMALEF_SPACE_SUB);
                wL = flipArray(dest, start, e, wL);
                length = wL - start;
            }
            if (tashkeelOn && (lenOptionsTashkeel == TASHKEEL_RESIZE)) {
                shiftArray(dest, start, e, TASHKEEL_SPACE_SUB);
                wT = flipArray(dest, start, e, wT);
                length = wT - start;
            }

            lamAlefOn = false;
            tashkeelOn = false;

            if ((lenOptionsLamAlef == LAMALEF_BEGIN) || (lenOptionsLamAlef == LAMALEF_AUTO)) {
                lamAlefOn = true;
            }
            if (lenOptionsTashkeel == TASHKEEL_BEGIN) {
                tashkeelOn = true;
            }

            if (lamAlefOn
                    && ((lenOptionsLamAlef == LAMALEF_BEGIN)
                            || (lenOptionsLamAlef == LAMALEF_AUTO))) { // spaces at beginning
                shiftArray(dest, start, e, LAMALEF_SPACE_SUB);
                wL = flipArray(dest, start, e, wL);
                while (wL < e) {
                    dest[wL++] = SPACE_CHAR;
                }
            }
            if (tashkeelOn && (lenOptionsTashkeel == TASHKEEL_BEGIN)) {
                shiftArray(dest, start, e, TASHKEEL_SPACE_SUB);
                wT = flipArray(dest, start, e, wT);
                while (wT < e) {
                    dest[wT++] = SPACE_CHAR;
                }
            }
        }

        return length;
    }

    /*
     *Name     :expandCompositCharAtBegin
     *Function :Expands the LamAlef character to Lam and Alef consuming the required
     *         space from beginning of the buffer. If the text type was visual_LTR
     *         and the option SPACES_RELATIVE_TO_TEXT_BEGIN_END was selected
     *         the spaces will be located at end of buffer.
     *         If there are no spaces to expand the LamAlef, an exception is thrown.
     */
    private boolean expandCompositCharAtBegin(char[] dest, int start, int length, int lacount) {
        boolean spaceNotFound = false;

        if (lacount > countSpacesRight(dest, start, length)) {
            spaceNotFound = true;
            return spaceNotFound;
        }
        for (int r = start + length - lacount, w = start + length; --r >= start; ) {
            char ch = dest[r];
            if (isNormalizedLamAlefChar(ch)) {
                dest[--w] = LAM_CHAR;
                dest[--w] = convertNormalizedLamAlef[ch - '\u065C'];
            } else {
                dest[--w] = ch;
            }
        }
        return spaceNotFound;
    }

    /*
     *Name     : expandCompositCharAtEnd
     *Function : Expands the LamAlef character to Lam and Alef consuming the
     *           required space from end of the buffer. If the text type was
     *           Visual LTR and the option SPACES_RELATIVE_TO_TEXT_BEGIN_END
     *           was used, the spaces will be consumed from begin of buffer. If
     *           there are no spaces to expand the LamAlef, an exception is thrown.
     */

    private boolean expandCompositCharAtEnd(char[] dest, int start, int length, int lacount) {
        boolean spaceNotFound = false;

        if (lacount > countSpacesLeft(dest, start, length)) {
            spaceNotFound = true;
            return spaceNotFound;
        }
        for (int r = start + lacount, w = start, e = start + length; r < e; ++r) {
            char ch = dest[r];
            if (isNormalizedLamAlefChar(ch)) {
                dest[w++] = convertNormalizedLamAlef[ch - '\u065C'];
                dest[w++] = LAM_CHAR;
            } else {
                dest[w++] = ch;
            }
        }
        return spaceNotFound;
    }

    /*
     *Name     : expandCompositCharAtNear
     *Function : Expands the LamAlef character into Lam + Alef, YehHamza character
     *           into Yeh + Hamza, SeenFamily character into SeenFamily character
     *           + Tail, while consuming the space next to the character.
     */

    private boolean expandCompositCharAtNear(
            char[] dest,
            int start,
            int length,
            int yehHamzaOption,
            int seenTailOption,
            int lamAlefOption) {

        boolean spaceNotFound = false;

        if (isNormalizedLamAlefChar(dest[start])) {
            spaceNotFound = true;
            return spaceNotFound;
        }
        for (int i = start + length; --i >= start; ) {
            char ch = dest[i];
            if (lamAlefOption == 1 && isNormalizedLamAlefChar(ch)) {
                if (i > start && dest[i - 1] == SPACE_CHAR) {
                    dest[i] = LAM_CHAR;
                    dest[--i] = convertNormalizedLamAlef[ch - '\u065C'];
                } else {
                    spaceNotFound = true;
                    return spaceNotFound;
                }
            } else if (seenTailOption == 1 && isSeenTailFamilyChar(ch) == 1) {
                if (i > start && dest[i - 1] == SPACE_CHAR) {
                    dest[i - 1] = tailChar;
                } else {
                    spaceNotFound = true;
                    return spaceNotFound;
                }
            } else if (yehHamzaOption == 1 && isYehHamzaChar(ch)) {

                if (i > start && dest[i - 1] == SPACE_CHAR) {
                    dest[i] = yehHamzaToYeh[ch - YEH_HAMZAFE_CHAR];
                    dest[i - 1] = HAMZAFE_CHAR;
                } else {
                    spaceNotFound = true;
                    return spaceNotFound;
                }
            }
        }
        return false;
    }

    /*
     * Name    : expandCompositChar
     * Function: LamAlef needs special handling as the LamAlef is
     *           one character while expanding it will give two
     *           characters Lam + Alef, so we need to expand the LamAlef
     *           in near or far spaces according to the options the user
     *           specifies or increase the buffer size.
     *           Dest has enough room for the expansion if we are growing.
     *           lamalef are normalized to the 'special characters'
     */
    private int expandCompositChar(char[] dest, int start, int length, int lacount, int shapingMode)
            throws ArabicShapingException {

        int lenOptionsLamAlef = options & LAMALEF_MASK;
        int lenOptionsSeen = options & SEEN_MASK;
        int lenOptionsYehHamza = options & YEHHAMZA_MASK;
        boolean spaceNotFound = false;

        if (!isLogical && !spacesRelativeToTextBeginEnd) {
            switch (lenOptionsLamAlef) {
                case LAMALEF_BEGIN:
                    lenOptionsLamAlef = LAMALEF_END;
                    break;
                case LAMALEF_END:
                    lenOptionsLamAlef = LAMALEF_BEGIN;
                    break;
                default:
                    break;
            }
        }

        if (shapingMode == 1) {
            if (lenOptionsLamAlef == LAMALEF_AUTO) {
                if (isLogical) {
                    spaceNotFound = expandCompositCharAtEnd(dest, start, length, lacount);
                    if (spaceNotFound) {
                        spaceNotFound = expandCompositCharAtBegin(dest, start, length, lacount);
                    }
                    if (spaceNotFound) {
                        spaceNotFound = expandCompositCharAtNear(dest, start, length, 0, 0, 1);
                    }
                    if (spaceNotFound) {
                        throw new ArabicShapingException("No spacefor lamalef");
                    }
                } else {
                    spaceNotFound = expandCompositCharAtBegin(dest, start, length, lacount);
                    if (spaceNotFound) {
                        spaceNotFound = expandCompositCharAtEnd(dest, start, length, lacount);
                    }
                    if (spaceNotFound) {
                        spaceNotFound = expandCompositCharAtNear(dest, start, length, 0, 0, 1);
                    }
                    if (spaceNotFound) {
                        throw new ArabicShapingException("No spacefor lamalef");
                    }
                }
            } else if (lenOptionsLamAlef == LAMALEF_END) {
                spaceNotFound = expandCompositCharAtEnd(dest, start, length, lacount);
                if (spaceNotFound) {
                    throw new ArabicShapingException("No spacefor lamalef");
                }
            } else if (lenOptionsLamAlef == LAMALEF_BEGIN) {
                spaceNotFound = expandCompositCharAtBegin(dest, start, length, lacount);
                if (spaceNotFound) {
                    throw new ArabicShapingException("No spacefor lamalef");
                }
            } else if (lenOptionsLamAlef == LAMALEF_NEAR) {
                spaceNotFound = expandCompositCharAtNear(dest, start, length, 0, 0, 1);
                if (spaceNotFound) {
                    throw new ArabicShapingException("No spacefor lamalef");
                }
            } else if (lenOptionsLamAlef == LAMALEF_RESIZE) {
                for (int r = start + length, w = r + lacount; --r >= start; ) {
                    char ch = dest[r];
                    if (isNormalizedLamAlefChar(ch)) {
                        dest[--w] = '\u0644';
                        dest[--w] = convertNormalizedLamAlef[ch - '\u065C'];
                    } else {
                        dest[--w] = ch;
                    }
                }
                length += lacount;
            }
        } else {
            if (lenOptionsSeen == SEEN_TWOCELL_NEAR) {
                spaceNotFound = expandCompositCharAtNear(dest, start, length, 0, 1, 0);
                if (spaceNotFound) {
                    throw new ArabicShapingException("No space for Seen tail expansion");
                }
            }
            if (lenOptionsYehHamza == YEHHAMZA_TWOCELL_NEAR) {
                spaceNotFound = expandCompositCharAtNear(dest, start, length, 1, 0, 0);
                if (spaceNotFound) {
                    throw new ArabicShapingException("No space for YehHamza expansion");
                }
            }
        }
        return length;
    }

    /* Convert the input buffer from FExx Range into 06xx Range
     * to put all characters into the 06xx range
     * even the lamalef is converted to the special region in
     * the 06xx range.  Return the number of lamalef chars found.
     */
    private int normalize(char[] dest, int start, int length) {
        int lacount = 0;
        for (int i = start, e = i + length; i < e; ++i) {
            char ch = dest[i];
            if (ch >= '\uFE70' && ch <= '\uFEFC') {
                if (isLamAlefChar(ch)) {
                    ++lacount;
                }
                dest[i] = (char) convertFEto06[ch - '\uFE70'];
            }
        }
        return lacount;
    }

    /*
     * Name    : deshapeNormalize
     * Function: Convert the input buffer from FExx Range into 06xx Range
     *           even the lamalef is converted to the special region in the 06xx range.
     *           According to the options the user enters, all seen family characters
     *           followed by a tail character are merged to seen tail family character and
     *           any yeh followed by a hamza character are merged to yehhamza character.
     *           Method returns the number of lamalef chars found.
     */
    private int deshapeNormalize(char[] dest, int start, int length) {
        int lacount = 0;
        int yehHamzaComposeEnabled = 0;
        int seenComposeEnabled = 0;

        yehHamzaComposeEnabled = ((options & YEHHAMZA_MASK) == YEHHAMZA_TWOCELL_NEAR) ? 1 : 0;
        seenComposeEnabled = ((options & SEEN_MASK) == SEEN_TWOCELL_NEAR) ? 1 : 0;

        for (int i = start, e = i + length; i < e; ++i) {
            char ch = dest[i];

            if ((yehHamzaComposeEnabled == 1)
                    && ((ch == HAMZA06_CHAR) || (ch == HAMZAFE_CHAR))
                    && (i < (length - 1))
                    && isAlefMaksouraChar(dest[i + 1])) {
                dest[i] = SPACE_CHAR;
                dest[i + 1] = YEH_HAMZA_CHAR;
            } else if ((seenComposeEnabled == 1)
                    && (isTailChar(ch))
                    && (i < (length - 1))
                    && (isSeenTailFamilyChar(dest[i + 1]) == 1)) {
                dest[i] = SPACE_CHAR;
            } else if (ch >= '\uFE70' && ch <= '\uFEFC') {
                if (isLamAlefChar(ch)) {
                    ++lacount;
                }
                dest[i] = (char) convertFEto06[ch - '\uFE70'];
            }
        }
        return lacount;
    }

    /*
     * Name    : shapeUnicode
     * Function: Converts an Arabic Unicode buffer in 06xx Range into a shaped
     *           arabic Unicode buffer in FExx Range
     */
    private int shapeUnicode(char[] dest, int start, int length, int destSize, int tashkeelFlag)
            throws ArabicShapingException {

        int lamalef_count = normalize(dest, start, length);

        // resolve the link between the characters.
        // Arabic characters have four forms: Isolated, Initial, Medial and Final.
        // Tashkeel characters have two, isolated or medial, and sometimes only isolated.
        // tashkeelFlag == 0: shape normally, 1: shape isolated, 2: don't shape

        boolean lamalef_found = false, seenfam_found = false;
        boolean yehhamza_found = false, tashkeel_found = false;
        int i = start + length - 1;
        int currLink = getLink(dest[i]);
        int nextLink = 0;
        int prevLink = 0;
        int lastLink = 0;
        // int prevPos = i;
        int lastPos = i;
        int nx = -2;
        int nw = 0;

        while (i >= 0) {
            // If high byte of currLink != 0 then there might be more than one shape
            if ((currLink & '\uFF00') != 0 || isTashkeelChar(dest[i])) {
                nw = i - 1;
                nx = -2;
                while (nx < 0) { // we need to know about next char
                    if (nw == -1) {
                        nextLink = 0;
                        nx = Integer.MAX_VALUE;
                    } else {
                        nextLink = getLink(dest[nw]);
                        if ((nextLink & IRRELEVANT) == 0) {
                            nx = nw;
                        } else {
                            --nw;
                        }
                    }
                }

                if (((currLink & ALEFTYPE) > 0) && ((lastLink & LAMTYPE) > 0)) {
                    lamalef_found = true;
                    char wLamalef = changeLamAlef(dest[i]); // get from 0x065C-0x065f
                    if (wLamalef != '\u0000') {
                        // replace alef by marker, it will be removed later
                        dest[i] = '\uffff';
                        dest[lastPos] = wLamalef;
                        i = lastPos;
                    }

                    lastLink = prevLink;
                    currLink = getLink(wLamalef); // requires '\u0000', unfortunately
                }
                if ((i > 0) && (dest[i - 1] == SPACE_CHAR)) {
                    if (isSeenFamilyChar(dest[i]) == 1) {
                        seenfam_found = true;
                    } else if (dest[i] == YEH_HAMZA_CHAR) {
                        yehhamza_found = true;
                    }
                } else if (i == 0) {
                    if (isSeenFamilyChar(dest[i]) == 1) {
                        seenfam_found = true;
                    } else if (dest[i] == YEH_HAMZA_CHAR) {
                        yehhamza_found = true;
                    }
                }

                // get the proper shape according to link ability of neighbors
                // and of character; depends on the order of the shapes
                // (isolated, initial, middle, final) in the compatibility area

                int flag = specialChar(dest[i]);

                int shape =
                        shapeTable[nextLink & LINK_MASK][lastLink & LINK_MASK][
                                currLink & LINK_MASK];

                if (flag == 1) {
                    shape &= 0x1;
                } else if (flag == 2) {
                    if (tashkeelFlag == 0
                            && ((lastLink & LINKL) != 0)
                            && ((nextLink & LINKR) != 0)
                            && dest[i] != '\u064C'
                            && dest[i] != '\u064D'
                            && !((nextLink & ALEFTYPE) == ALEFTYPE
                                    && (lastLink & LAMTYPE) == LAMTYPE)) {

                        shape = 1;

                    } else if (tashkeelFlag == 2 && dest[i] == SHADDA06_CHAR) {
                        shape = 1;

                    } else {
                        shape = 0;
                    }
                }
                if (flag == 2) {
                    if (tashkeelFlag == 2 && dest[i] != SHADDA06_CHAR) {
                        dest[i] = TASHKEEL_SPACE_SUB;
                        tashkeel_found = true;
                    } else {
                        dest[i] = (char) ('\uFE70' + irrelevantPos[dest[i] - '\u064B'] + shape);
                    }
                    // else leave tashkeel alone
                } else {
                    dest[i] = (char) ('\uFE70' + (currLink >> 8) + shape);
                }
            }

            // move one notch forward
            if ((currLink & IRRELEVANT) == 0) {
                prevLink = lastLink;
                lastLink = currLink;
                // prevPos = lastPos;
                lastPos = i;
            }

            --i;
            if (i == nx) {
                currLink = nextLink;
                nx = -2;
            } else if (i != -1) {
                currLink = getLink(dest[i]);
            }
        }

        // If we found a lam/alef pair in the buffer
        // call handleGeneratedSpaces to remove the spaces that were added

        destSize = length;
        if (lamalef_found || tashkeel_found) {
            destSize = handleGeneratedSpaces(dest, start, length);
        }
        if (seenfam_found || yehhamza_found) {
            destSize = expandCompositChar(dest, start, destSize, lamalef_count, SHAPE_MODE);
        }
        return destSize;
    }

    /*
     * Name    : deShapeUnicode
     * Function: Converts an Arabic Unicode buffer in FExx Range into unshaped
     *           arabic Unicode buffer in 06xx Range
     */
    private int deShapeUnicode(char[] dest, int start, int length, int destSize)
            throws ArabicShapingException {

        int lamalef_count = deshapeNormalize(dest, start, length);

        // If there was a lamalef in the buffer call expandLamAlef
        if (lamalef_count != 0) {
            // need to adjust dest to fit expanded buffer... !!!
            destSize = expandCompositChar(dest, start, length, lamalef_count, DESHAPE_MODE);
        } else {
            destSize = length;
        }

        return destSize;
    }

    private int internalShape(
            char[] source,
            int sourceStart,
            int sourceLength,
            char[] dest,
            int destStart,
            int destSize)
            throws ArabicShapingException {

        if (sourceLength == 0) {
            return 0;
        }

        if (destSize == 0) {
            if (((options & LETTERS_MASK) != LETTERS_NOOP)
                    && ((options & LAMALEF_MASK) == LAMALEF_RESIZE)) {

                return calculateSize(source, sourceStart, sourceLength);
            } else {
                return sourceLength; // by definition
            }
        }

        // always use temp buffer
        char[] temp = new char[sourceLength * 2]; // all lamalefs requiring expansion
        System.arraycopy(source, sourceStart, temp, 0, sourceLength);

        if (isLogical) {
            invertBuffer(temp, 0, sourceLength);
        }

        int outputSize = sourceLength;

        switch (options & LETTERS_MASK) {
            case LETTERS_SHAPE_TASHKEEL_ISOLATED:
                outputSize = shapeUnicode(temp, 0, sourceLength, destSize, 1);
                break;

            case LETTERS_SHAPE:
                if (((options & TASHKEEL_MASK) != 0)
                        && ((options & TASHKEEL_MASK) != TASHKEEL_REPLACE_BY_TATWEEL)) {
                    /* Call the shaping function with tashkeel flag == 2 for removal of tashkeel */
                    outputSize = shapeUnicode(temp, 0, sourceLength, destSize, 2);
                } else {
                    // default Call the shaping function with tashkeel flag == 1 */
                    outputSize = shapeUnicode(temp, 0, sourceLength, destSize, 0);

                    /*After shaping text check if user wants to remove tashkeel and replace it with tatweel*/
                    if ((options & TASHKEEL_MASK) == TASHKEEL_REPLACE_BY_TATWEEL) {
                        outputSize = handleTashkeelWithTatweel(temp, sourceLength);
                    }
                }
                break;

            case LETTERS_UNSHAPE:
                outputSize = deShapeUnicode(temp, 0, sourceLength, destSize);
                break;

            default:
                break;
        }

        if (outputSize > destSize) {
            throw new ArabicShapingException("not enough room for result data");
        }

        if ((options & DIGITS_MASK) != DIGITS_NOOP) {
            char digitBase = '\u0030'; // European digits
            switch (options & DIGIT_TYPE_MASK) {
                case DIGIT_TYPE_AN:
                    digitBase = '\u0660'; // Arabic-Indic digits
                    break;

                case DIGIT_TYPE_AN_EXTENDED:
                    digitBase = '\u06f0'; // Eastern Arabic-Indic digits (Persian and Urdu)
                    break;

                default:
                    break;
            }

            switch (options & DIGITS_MASK) {
                case DIGITS_EN2AN:
                    {
                        int digitDelta = digitBase - '\u0030';
                        for (int i = 0; i < outputSize; ++i) {
                            char ch = temp[i];
                            if (ch <= '\u0039' && ch >= '\u0030') {
                                temp[i] += digitDelta;
                            }
                        }
                    }
                    break;

                case DIGITS_AN2EN:
                    {
                        char digitTop = (char) (digitBase + 9);
                        int digitDelta = '\u0030' - digitBase;
                        for (int i = 0; i < outputSize; ++i) {
                            char ch = temp[i];
                            if (ch <= digitTop && ch >= digitBase) {
                                temp[i] += digitDelta;
                            }
                        }
                    }
                    break;

                case DIGITS_EN2AN_INIT_LR:
                    shapeToArabicDigitsWithContext(temp, 0, outputSize, digitBase, false);
                    break;

                case DIGITS_EN2AN_INIT_AL:
                    shapeToArabicDigitsWithContext(temp, 0, outputSize, digitBase, true);
                    break;

                default:
                    break;
            }
        }

        if (isLogical) {
            invertBuffer(temp, 0, outputSize);
        }

        System.arraycopy(temp, 0, dest, destStart, outputSize);

        return outputSize;
    }
}
